home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / bash_114.zip / bash-1.14.2 / builtins / getopts.def < prev    next >
Encoding:
Text File  |  1994-07-26  |  8.1 KB  |  314 lines
  1. This file is getopts.def, from which is created getopts.c.
  2. It implements the builtin "getopts" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES getopts.c
  23.  
  24. $BUILTIN getopts
  25. $DEPENDS_ON GETOPTS_BUILTIN
  26. $FUNCTION getopts_builtin
  27. $SHORT_DOC getopts optstring name [arg]
  28. Getopts is used by shell procedures to parse positional parameters.
  29.  
  30. OPTSTRING contains the option letters to be recognized; if a letter
  31. is followed by a colon, the option is expected to have an argument,
  32. which should be separated from it by white space.
  33.  
  34. Each time it is invoked, getopts will place the next option in the
  35. shell variable $name, initializing name if it does not exist, and
  36. the index of the next argument to be processed into the shell
  37. variable OPTIND.  OPTIND is initialized to 1 each time the shell or
  38. a shell script is invoked.  When an option requires an argument,
  39. getopts places that argument into the shell variable OPTARG.
  40.  
  41. getopts reports errors in one of two ways.  If the first character
  42. of OPTSTRING is a colon, getopts uses silent error reporting.  In
  43. this mode, no error messages are printed.  If an illegal option is
  44. seen, getopts places the option character found into OPTARG.  If a
  45. required argument is not found, getopts places a ':' into NAME and
  46. sets OPTARG to the option character found.  If getopts is not in
  47. silent mode, and an illegal option is seen, getopts places '?' into
  48. NAME and unsets OPTARG.  If a required option is not found, a '?'
  49. is placed in NAME, OPTARG is unset, and a diagnostic message is
  50. printed.
  51.  
  52. If the shell variable OPTERR has the value 0, getopts disables the
  53. printing of error messages, even if the first character of
  54. OPTSTRING is not a colon.  OPTERR has the value 1 by default.
  55.  
  56. Getopts normally parses the positional parameters ($0 - $9), but if
  57. more arguments are given, they are parsed instead.
  58. $END
  59.  
  60. #include <stdio.h>
  61.  
  62. #if defined (HAVE_STRING_H)
  63. #  include <string.h>
  64. #else /* !HAVE_STRING_H */
  65. #  include <strings.h>
  66. #endif /* !HAVE_STRING_H */
  67.  
  68. #include "../shell.h"
  69.  
  70. #if defined (GETOPTS_BUILTIN)
  71. #include "getopt.h"
  72.  
  73. #define G_EOF        (-1)
  74. #define G_ILLEGAL_OPT    (-2)
  75. #define G_ARG_MISSING    (-3)
  76.  
  77. /* getopt.c is not compiled if __GNU_LIBRARY__ is defined, so this
  78.    function will come up as undefined.  More's the pity; the default
  79.    behavior of the GNU getopt() is not Posix.2 compliant. */
  80. #if defined (__GNU_LIBRARY__)
  81. #  define getopt_set_posix_option_order(x)
  82. #endif
  83.  
  84. extern char *this_command_name;
  85. extern WORD_LIST *rest_of_args;
  86.  
  87. /* getopts_reset is magic code for when OPTIND is reset.  N is the
  88.    value that has just been assigned to OPTIND. */
  89. void
  90. getopts_reset (newind)
  91.      int newind;
  92. {
  93.   optind = newind;
  94. }
  95.  
  96. /* Error handling is now performed as specified by Posix.2, draft 11
  97.    (identical to that of ksh-88).  The special handling is enabled if
  98.    the first character of the option string is a colon; this handling
  99.    disables diagnostic messages concerning missing option arguments
  100.    and illegal option characters.  The handling is as follows.
  101.  
  102.    ILLEGAL OPTIONS:
  103.         name -> "?"
  104.         if (special_error) then
  105.                 OPTARG = option character found
  106.                 no error output
  107.         else
  108.                 OPTARG unset
  109.                 diagnostic message
  110.         fi
  111.  
  112.   MISSING OPTION ARGUMENT;
  113.         if (special_error) then
  114.                 name -> ":"
  115.                 OPTARG = option character found
  116.         else
  117.                 name -> "?"
  118.                 OPTARG unset
  119.                 diagnostic message
  120.         fi
  121.  */
  122.  
  123. static int
  124. dogetopts (argc, argv)
  125.      int argc;
  126.      char **argv;
  127. {
  128.   int ret, special_error, old_opterr = 0, i, n;
  129.   char strval[2], numval[16];
  130.   char *optstr;            /* list of options */
  131.   char *name;            /* variable to get flag val */
  132.   char *t;
  133.  
  134.   if (argc < 3)
  135.     {
  136.       builtin_error("usage: getopts optstring name [arg]");
  137.       return (EX_USAGE);
  138.     }
  139.  
  140.   /* argv[0] is "getopts". */
  141.  
  142.   optstr = argv[1];
  143.   name = argv[2];
  144.   argc -= 2;
  145.   argv += 2;
  146.  
  147.   special_error = optstr[0] == ':';
  148.  
  149.   if (special_error)
  150.     {
  151.       old_opterr = opterr;
  152.       optstr++;
  153.       opterr = 0;        /* suppress diagnostic messages */
  154.     }
  155.  
  156.   if (argc > 1)
  157.     {
  158.       t = argv[0];
  159.       argv[0] = dollar_vars[0];
  160.       ret = getopt (argc, argv, optstr);
  161.       argv[0] = t;
  162.     }
  163.   else if (rest_of_args == (WORD_LIST *)NULL)
  164.     {
  165.       register int i;
  166.  
  167.       for (i = 0; dollar_vars[i]; i++);
  168.       ret = getopt (i, dollar_vars, optstr);
  169.     }
  170.   else
  171.     {
  172.       register int i;
  173.       register WORD_LIST *words;
  174.       char **v;
  175.  
  176.       for (i = 0; dollar_vars[i]; i++);
  177.       for (words = rest_of_args; words; words = words->next, i++);
  178.       v = (char **)xmalloc ((i + 1) * sizeof (char *));
  179.       for (i = 0; dollar_vars[i]; i++)
  180.         v[i] = dollar_vars[i];
  181.       for (words = rest_of_args; words; words = words->next, i++)
  182.         v[i] = words->word->word;
  183.       v[i] = (char *)NULL;
  184.       ret = getopt (i, v, optstr);
  185.       free (v);
  186.     }
  187.  
  188.   if (special_error)
  189.     opterr = old_opterr;
  190.  
  191.   /* Set the OPTIND variable in any case, to handle "--" skipping. */
  192.   if (optind < 10)
  193.     {
  194.       numval[14] = optind + '0';
  195.       numval[15] = '\0';
  196.       i = 14;
  197.     }
  198.   else
  199.     {
  200.       numval[i = 15] = '\0';
  201.       n = optind;
  202.       do
  203.     {
  204.       numval[--i] = (n % 10) + '0';
  205.     }
  206.       while (n /= 10);
  207.     }
  208.   bind_variable ("OPTIND", numval + i);
  209.  
  210.   /* If an error occurred, decide which one it is and set the return
  211.      code appropriately.  In all cases, the option character in error
  212.      is in OPTOPT.  If an illegal option was encountered, OPTARG is
  213.      NULL.  If a required option argument was missing, OPTARG points
  214.      to a NULL string (that is, optarg[0] == 0). */
  215.   if (ret == '?')
  216.     {
  217.       if (optarg == NULL)
  218.     ret = G_ILLEGAL_OPT;
  219.       else if (optarg[0] == '\0')
  220.     ret = G_ARG_MISSING;
  221.     }
  222.         
  223.   if (ret == G_EOF)
  224.     {
  225.       bind_variable (name, "?");
  226.       return (EXECUTION_FAILURE);
  227.     }
  228.  
  229.   if (ret == G_ILLEGAL_OPT)
  230.     {
  231.       /* Illegal option encountered. */
  232.       strval[0] = '?';
  233.       strval[1] = '\0';
  234.       bind_variable (name, strval);
  235.  
  236.       if (special_error)
  237.     {
  238.       strval[0] = (char) optopt;
  239.       strval[1] = '\0';
  240.       bind_variable ("OPTARG", strval);
  241.     }
  242.       else
  243.     makunbound ("OPTARG", shell_variables);
  244.       return (EXECUTION_SUCCESS);
  245.     }
  246.  
  247.   if (ret == G_ARG_MISSING)
  248.     {
  249.       /* Required argument missing. */
  250.       if (special_error)
  251.     {
  252.       strval[0] = ':';
  253.       strval[1] = '\0';
  254.       bind_variable (name, strval);
  255.  
  256.       strval[0] = (char) optopt;
  257.       strval[1] = '\0';
  258.       bind_variable ("OPTARG", strval);
  259.     }
  260.       else
  261.     {
  262.       strval[0] = '?';
  263.       strval[1] = '\0';
  264.       bind_variable (name, strval);
  265.       makunbound ("OPTARG", shell_variables);
  266.     }
  267.       return (EXECUTION_SUCCESS);
  268.     }            
  269.  
  270.   bind_variable ("OPTARG", optarg);
  271.  
  272.   strval[0] = (char) ret;
  273.   strval[1] = '\0';
  274.   bind_variable (name, strval);
  275.  
  276.   return (EXECUTION_SUCCESS);
  277. }
  278.  
  279. /* The getopts builtin.  Build an argv, and call dogetopts with it. */
  280. int
  281. getopts_builtin (list)
  282.      WORD_LIST *list;
  283. {
  284.   register int    i;
  285.   char **av;
  286.   int ac, ret;
  287.   WORD_LIST *t = list;
  288.   static int order_set = 0;
  289.  
  290.   if (!list)
  291.     return EXECUTION_FAILURE;
  292.  
  293.   for (ac = 0; t; t = t->next, ac++);
  294.  
  295.   ac++;
  296.   av = (char **)xmalloc ((1 + ac) * sizeof (char *));
  297.   av[ac] = (char *) NULL;
  298.   av[0] = savestring (this_command_name);
  299.  
  300.   for (t = list, i = 1; t; t = t->next, i++)
  301.     av[i] = savestring (t->word->word);
  302.  
  303.   if (order_set == 0)
  304.     {
  305.       getopt_set_posix_option_order (1);
  306.       order_set++;
  307.     }
  308.  
  309.   ret = dogetopts (ac, av);
  310.   free_array (av);
  311.   return (ret);
  312. }
  313. #endif /* GETOPTS_BUILTIN */
  314.